printf(MYNAME "-GPSLongitude = %12.7f\n", wpt->longitude);
}
if (!datum.isEmpty()) {
- int idatum = gt_lookup_datum_index(datum.constData(), MYNAME);
+ int idatum = gt_lookup_datum_index(datum, MYNAME);
if (idatum < 0) {
fatal(MYNAME ": Unknown GPSMapDatum \"%s\"!\n", datum.constData());
}
#ifndef GARMIN_ICON_TABLES_H
#define GARMIN_ICON_TABLES_H
+#include <QString>
+#include <QVector>
+
#include "garmin_tables.h"
+struct icon_mapping_t {
+ int mpssymnum;
+ int pcxsymnum;
+ QString icon;
+};
+
/* MapSource 4.13 */
-const icon_mapping_t garmin_icon_table[] = {
+static const QVector<icon_mapping_t> garmin_icon_table = {
/* mps pcx desc */
{ 107, 16384, "Airport" },
{ 73, 8204, "Amusement Park" },
{ 246, -1, "Upland Game" },
{ 247, -1, "Waterfowl" },
{ 248, -1, "Water Source" },
-
-
- { -1, -1, nullptr },
};
-const icon_mapping_t garmin_smart_icon_table[] = {
+static const QVector<icon_mapping_t> garmin_smart_icon_table = {
/* Additional (optional, activated with -Si) icons */
{ 92, 8227, "Micro-Cache" }, /* icon for "Toll Booth" */
{ 48, 161, "Virtual cache" }, /* icon for "Scenic Area" */
{ 83, 8214, "Post Office" }, /* Icon for "Post Office" */
{ 47, 160, "Event Cache" }, /* Icon for "Event" */
{ 90, 8221, "Webcam Cache" }, /* Icon for "Live Theatre" */
- { -1, -1, nullptr }
};
#endif // GARMIN_ICON_TABLES_H
#include <cstdint> // for int32_t
#include <cstring> // for strncpy, strchr, strlen, strncmp
+
#include <QChar> // for operator==, QChar
#include <QDebug> // for QDebug
+#include <QVector> // for QVector
#include <Qt> // for CaseInsensitive
+
#include "defs.h"
#include "garmin_tables.h"
#include "jeeps/gpsmath.h" // for GPS_Lookup_Datum_Index, GPS_Math_Get_Datum_Name
// these tables are in an include file so they can be shared with mkicondoc.
#include "garmin_icon_tables.h" // for garmin_icon_table, garmin_smart_icon_table
+
+#define DEFAULT_ICON_DESCR "Waypoint"
+#define DEFAULT_ICON_VALUE 18
+
/* ICAO country code table */
/* source: https://en.wikipedia.org/wiki/ICAO_airport_code */
-const gt_country_code_t gt_country_codes[] = {
+struct gt_country_code_t {
+ const char* cc;
+ const char* country;
+};
+
+static const gt_country_code_t gt_country_codes[] = {
{ "ZM,", "Mongolia" },
{ "ZK,", "North Korea" },
{ "Z*,", "China" },
};
/* gt_waypt_classes: gdb internal order */
-const char* const gt_waypt_class_names[] = {
+const QStringList gt_waypt_class_names = {
"User Waypoint",
"Airport",
"Intersection",
"Map Intersection",
"Map Address",
"Map Line",
- nullptr
};
/* gt_display_mode_names: this order is used by most devices */
-const char* const gt_display_mode_names[] = {
+const QStringList gt_display_mode_names = {
"Symbol & Name",
"Symbol",
"Symbol & Description"
};
struct grid_mapping_t {
- const char* shortname;
- const char* longname;
+ QString shortname;
+ QString longname;
grid_type grid;
};
/* gt_mps_grid_names: !!! degree sign substituted with '*' !!! */
-static const grid_mapping_t gt_mps_grid_names[] = {
+static const QVector<grid_mapping_t> gt_mps_grid_names = {
{ "ddd", "Lat/Lon hddd.ddddd*", grid_lat_lon_ddd },
{ "dmm", "Lat/Lon hddd*mm.mmm'", grid_lat_lon_dmm },
{ "dms", "Lat/Lon hddd*mm'ss.s\"", grid_lat_lon_dms },
{ "bng", "British National Grid", grid_bng },
{ "utm", "UTM", grid_utm },
{ "swiss", "Swiss grid", grid_swiss },
- { nullptr, nullptr, (grid_type) 0 }
};
/* gt_mps_datum_names: */
struct datum_mapping_t {
- const char* jeeps_name;
- const char* mps_name;
+ QString jeeps_name;
+ QString mps_name;
};
/* will be continued (when requested) */
-static const datum_mapping_t gt_mps_datum_names[] = {
+static const QVector<datum_mapping_t> gt_mps_datum_names = {
{ "Alaska-NAD27", "NAD27 Alaska" },
{ "Bahamas NAD27", "NAD27 Bahamas" },
{ "Canada_Mean(NAD27)", "NAD27 Canada" },
{ "Mexico NAD27", "NAD27 Mexico" },
{ "North America 83", "NAD83" },
{ "OSGB36", "Ord Srvy Grt Britn" },
- { nullptr, nullptr }
};
struct garmin_color_t {
- const char* name;
+ QString name;
int32_t rgb;
};
-static const garmin_color_t gt_colors[] = {
+static const QVector<garmin_color_t> gt_colors = {
{ "Unknown", unknown_color },
{ "Black", 0x000000 },
{ "DarkRed", 0x00008B },
{ "Cyan", 0xFFFF00 },
{ "White", 0xFFFFFF },
{ "Transparent", unknown_color }, /* Currently not handled */
- { nullptr, 0 }
};
-#define GT_COLORS_CT ((sizeof(gt_colors) / sizeof(gt_colors[0])) - 1)
-
unsigned char
gt_switch_display_mode_value(const unsigned char display_mode, const int protoid, const char device)
{
return QStringLiteral("Custom %1").arg(icon - 7680);
}
- for (const icon_mapping_t* i = garmin_icon_table; i->icon; i++) {
+ for (const auto& icon_mapping : garmin_icon_table) {
switch (garmin_format) {
case MAPSOURCE:
case GDB:
- if (icon == i->mpssymnum) {
- return i->icon;
+ if (icon == icon_mapping.mpssymnum) {
+ return icon_mapping.icon;
}
break;
case PCX:
case GARMIN_SERIAL:
- if (icon == i->pcxsymnum) {
- return i->icon;
+ if (icon == icon_mapping.pcxsymnum) {
+ return icon_mapping.icon;
}
break;
default:
int gt_find_icon_number_from_desc(const QString& desc, garmin_formats_e garmin_format)
{
static int find_flag = 0;
- const icon_mapping_t* i;
int def_icon = DEFAULT_ICON_VALUE;
if (desc.isNull()) {
}
}
- for (i = garmin_smart_icon_table; global_opts.smart_icons && i->icon; i++) {
- if (desc.compare(i->icon, Qt::CaseInsensitive) == 0) {
- switch (garmin_format) {
- case MAPSOURCE:
- case GDB:
- return i->mpssymnum;
- case PCX:
- case GARMIN_SERIAL:
- return i->pcxsymnum;
- default:
- fatal(MYNAME ": unknown garmin format.\n");
+ if (global_opts.smart_icons) {
+ for (const auto& icon_mapping : garmin_smart_icon_table) {
+ if (desc.compare(icon_mapping.icon, Qt::CaseInsensitive) == 0) {
+ switch (garmin_format) {
+ case MAPSOURCE:
+ case GDB:
+ return icon_mapping.mpssymnum;
+ case PCX:
+ case GARMIN_SERIAL:
+ return icon_mapping.pcxsymnum;
+ default:
+ fatal(MYNAME ": unknown garmin format.\n");
+ }
}
}
}
- for (i = garmin_icon_table; i->icon; i++) {
- if (desc.compare(i->icon, Qt::CaseInsensitive) == 0) {
+ for (const auto& icon_mapping : garmin_icon_table) {
+ if (desc.compare(icon_mapping.icon, Qt::CaseInsensitive) == 0) {
switch (garmin_format) {
case MAPSOURCE:
case GDB:
- return i->mpssymnum;
+ return icon_mapping.mpssymnum;
case PCX:
case GARMIN_SERIAL:
- return i->pcxsymnum;
+ return icon_mapping.pcxsymnum;
default:
fatal(MYNAME ": unknown garmin format.\n");
}
*/
if (find_flag == 0) {
- const char* prefixes[] = {
- "White ", "Red ", "Green ", "Blue ", "Black ", nullptr
+ static const QStringList prefixes = {
+ "White ", "Red ", "Green ", "Blue ", "Black ",
};
// Rewrite "Green Square" to "Square, Green".
- for (const char** prefix = prefixes; *prefix != nullptr; prefix++) {
- if (desc.startsWith(*prefix, Qt::CaseInsensitive)) {
+ for (const auto& prefix : prefixes) {
+ if (desc.startsWith(prefix, Qt::CaseInsensitive)) {
QString buff = desc;
- buff.replace(*prefix, "");
+ buff.replace(prefix, "");
buff.append(", ");
- buff.append(*prefix);
+ buff.append(prefix);
buff = buff.trimmed();
find_flag = 1;
}
grid_type
-gt_lookup_grid_type(const char* grid_name, const QString& module)
+gt_lookup_grid_type(const QString& grid_name, const QString& module)
{
- for (const grid_mapping_t* g = gt_mps_grid_names; (g->shortname); g++) {
- if (QString::compare(grid_name, g->shortname, Qt::CaseInsensitive) == 0 ||
- QString::compare(grid_name, g->longname,Qt::CaseInsensitive) == 0) {
- return g->grid;
+ for (const auto& grid_mapping : gt_mps_grid_names) {
+ if (QString::compare(grid_name, grid_mapping.shortname, Qt::CaseInsensitive) == 0 ||
+ QString::compare(grid_name, grid_mapping.longname,Qt::CaseInsensitive) == 0) {
+ return grid_mapping.grid;
}
}
- fatal(FatalMsg() << module << ": Unsupported grid (" << grid_name <<
- ". See GPSBabel help for supported grids.\n");
+ fatal(FatalMsg().nospace().noquote() << module <<
+ ": Unsupported grid (" << grid_name <<
+ "). See GPSBabel help for supported grids.");
return grid_unknown; /* (warnings) */
}
-const char*
-gt_get_mps_grid_longname(const grid_type grid, const char* module)
+QString
+gt_get_mps_grid_longname(const grid_type grid, const QString& module)
{
- if ((grid < GRID_INDEX_MIN) || (grid > GRID_INDEX_MAX))
- fatal("%s: Grid index out of range %d (%d..%d)!",
- module, (int) grid,
- (int)GRID_INDEX_MIN, (int)GRID_INDEX_MAX);
+ if ((grid < GRID_INDEX_MIN) || (grid > GRID_INDEX_MAX)) {
+ fatal(FatalMsg().nospace().noquote() << module <<
+ ": Grid index out of range " << grid <<
+ " (" << GRID_INDEX_MIN << ".." << GRID_INDEX_MAX << ")!");
+ }
return gt_mps_grid_names[grid].longname;
}
-const char*
+QString
gt_get_mps_datum_name(const int datum_index)
{
- const char* result = GPS_Math_Get_Datum_Name(datum_index);
+ QString result = GPS_Math_Get_Datum_Name(datum_index);
- for (const datum_mapping_t* d = gt_mps_datum_names; (d->jeeps_name); d++)
- if (QString::compare(result, d->jeeps_name, Qt::CaseInsensitive) == 0) {
- return d->mps_name;
+ for (const auto& datum_mapping : gt_mps_datum_names) {
+ if (QString::compare(result, datum_mapping.jeeps_name, Qt::CaseInsensitive) == 0) {
+ return datum_mapping.mps_name;
}
+ }
return result;
}
int
-gt_lookup_datum_index(const char* datum_str, const QString& module)
+gt_lookup_datum_index(const QString& datum_str, const QString& module)
{
- const char* name = datum_str;
+ QString name = datum_str;
- for (const datum_mapping_t* d = gt_mps_datum_names; (d->jeeps_name); d++) {
- if (QString::compare(name, d->mps_name, Qt::CaseInsensitive) == 0) {
- name = d->jeeps_name;
+ for (const auto& datum_mapping : gt_mps_datum_names) {
+ if (QString::compare(name, datum_mapping.mps_name, Qt::CaseInsensitive) == 0) {
+ name = datum_mapping.jeeps_name;
break;
}
}
// Didn't get a hit? Try again after modifying the lookup.
if (result < 0) {
- QString tmp = QString(datum_str) + " mean";
+ QString tmp = datum_str + " mean";
result = GPS_Lookup_Datum_Index(tmp);
}
if (result < 0) {
- fatal(FatalMsg() << module << ": Unsupported datum (" << datum_str <<
- "). See GPSBabel help for supported datums.");
+ fatal(FatalMsg().nospace().noquote() << module <<
+ ": Unsupported datum (" << datum_str <<
+ "). See GPSBabel help for supported datums.");
}
return result;
}
uint32_t
gt_color_value(const unsigned int garmin_index)
{
- if ((garmin_index < GT_COLORS_CT)) {
+ if ((garmin_index < gt_colors.size())) {
return gt_colors[garmin_index].rgb;
} else {
return unknown_color; /* -1 */
uint32_t
gt_color_value_by_name(const QString& name)
{
- for (unsigned int i = 0; i < GT_COLORS_CT; i++)
+ for (int i = 0; i < gt_colors.size(); ++i) {
if (QString::compare(gt_colors[i].name, name, Qt::CaseInsensitive) == 0) {
return gt_colors[i].rgb;
}
+ }
return gt_colors[0].rgb;
}
int
gt_color_index_by_name(const QString& name)
{
- for (unsigned int i = 0; i < GT_COLORS_CT; i++)
+ for (int i = 0; i < gt_colors.size(); ++i) {
if (QString::compare(gt_colors[i].name, name, Qt::CaseInsensitive) == 0) {
return i;
}
+ }
return 0; /* unknown */
}
int
gt_color_index_by_rgb(const int rgb)
{
- for (unsigned int i = 0; i < GT_COLORS_CT; i++)
+ for (int i = 0; i < gt_colors.size(); ++i) {
if (rgb == gt_colors[i].rgb) {
return i;
}
+ }
return 0; /* unknown */
}
-const char*
+QString
gt_color_name(const unsigned int garmin_index)
{
- if ((garmin_index < GT_COLORS_CT)) {
+ if ((garmin_index < gt_colors.size())) {
return gt_colors[garmin_index].name;
} else {
return gt_colors[0].name;
#include <QString> // for QString
#include "defs.h" // for grid_type
-#define DEFAULT_ICON_DESCR "Waypoint"
-#define DEFAULT_ICON_VALUE 18
-
-struct icon_mapping_t {
- int mpssymnum;
- int pcxsymnum;
- const char* icon;
-};
enum garmin_formats_e {MAPSOURCE, PCX, GARMIN_SERIAL, GDB};
QString gt_find_desc_from_icon_number(int icon, garmin_formats_e garmin_format);
int gt_find_icon_number_from_desc(const QString& desc, garmin_formats_e garmin_format);
-extern const icon_mapping_t garmin_icon_table[];
-
enum gt_waypt_classes_e {
gt_waypt_class_user_waypoint = 0,
gt_waypt_class_airport,
gt_waypt_class_map_line
};
-extern const char* const gt_waypt_class_names[];
-
-struct gt_country_code_t {
- const char* cc;
- const char* country;
-};
-
-extern const gt_country_code_t gt_country_codes[];
+extern const QStringList gt_waypt_class_names;
const char* gt_get_icao_country(const QString& cc);
const char* gt_get_icao_cc(const QString& country, const QString& shortname);
gt_display_mode_symbol_and_comment
};
-extern const char* const gt_display_mode_names[];
-
-#define GT_DISPLAY_MODE_MIN gt_display_mode_symbol_and_name
-#define GT_DISPLAY_MODE_MAX gt_display_mode_symbol_and_comment
+extern const QStringList gt_display_mode_names;
enum gt_gdb_display_modes_e {
gt_gdb_display_mode_symbol = 0,
gt_gdb_display_mode_symbol_and_comment
};
-unsigned char gt_convert_category(const char* name, int* category);
-
unsigned char gt_switch_display_mode_value(unsigned char display_mode, int protoid, char device);
-grid_type gt_lookup_grid_type(const char* grid_name, const QString& module);
-const char* gt_get_mps_grid_longname(grid_type grid, const char* module);
-int gt_lookup_datum_index(const char* datum_str, const QString& module);
-const char* gt_get_mps_datum_name(int datum_index);
+grid_type gt_lookup_grid_type(const QString& grid_name, const QString& module);
+QString gt_get_mps_grid_longname(grid_type grid, const QString& module);
+int gt_lookup_datum_index(const QString& datum_str, const QString& module);
+QString gt_get_mps_datum_name(int datum_index);
uint32_t gt_color_value(unsigned int garmin_index);
uint32_t gt_color_value_by_name(const QString& name);
int gt_color_index_by_name(const QString& name);
int gt_color_index_by_rgb(int rgb);
-const char* gt_color_name(unsigned int garmin_index);
+QString gt_color_name(unsigned int garmin_index);
#endif
#include <ctime> // for gmtime, time_t, localtime, strftime, tm
#include <optional> // for optional
-#include <type_traits> // for add_const_t
#include <utility> // for pair, as_const, make_pair
#include <QByteArray> // for QByteArray
#include <QChar> // for QChar, QChar::Other_Control
"Name\tStart Time\tElapsed Time\tLength\tAverage Speed\tLink"
};
-inline gt_display_modes_e& operator++(gt_display_modes_e& s) // prefix
-{
- return s = static_cast<gt_display_modes_e>(s + 1);
-}
-inline gt_display_modes_e operator++(gt_display_modes_e& s, int) // postfix
-{
- gt_display_modes_e ret(s);
- ++s;
- return ret;
-}
bool GarminTxtFormat::is_valid_alt(double alt)
{
fatal(MYNAME ": %s (%s) is outside of convertible area \"%s\"!\n",
wpt->shortname.isEmpty() ? "Waypoint" : qPrintable(wpt->shortname),
qPrintable(pretty_deg_format(wpt->latitude, wpt->longitude, 'd', nullptr, false)),
- gt_get_mps_grid_longname(grid_index, MYNAME));
+ qPrintable(gt_get_mps_grid_longname(grid_index, MYNAME)));
}
}
void
GarminTxtFormat::write_waypt(const Waypoint* wpt)
{
- const char* wpt_type;
+ QString wpt_type;
const garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
int i = garmin_fs_t::get_display(gmsd, 0);
- if (i > GT_DISPLAY_MODE_MAX) {
+ if (!((i >= 0) && (i < gt_display_mode_names.size()))) {
i = 0;
}
- const char* dspl_mode = gt_display_mode_names[i];
+ QString dspl_mode = gt_display_mode_names[i];
int wpt_class = garmin_fs_t::get_wpt_class(gmsd, 0);
- if (wpt_class <= gt_waypt_class_map_line) {
+ if ((wpt_class >= 0) && (wpt_class < gt_waypt_class_names.size())) {
wpt_type = gt_waypt_class_names[wpt_class];
} else {
wpt_type = gt_waypt_class_names[0];
} else {
*fout << "\t";
}
- *fout << QString::asprintf("%s\t", wpt_type);
+ *fout << wpt_type << "\t";
print_position(wpt);
if (x != -999) {
print_temperature(x);
}
- *fout << QString::asprintf("\t%s\t", dspl_mode);
+ *fout << "\t" << dspl_mode << "\t";
*fout << "Unknown\t"; /* Color is fixed: Unknown */
}
}
- datum_str = get_option_val(opt_datum, nullptr);
- const char* grid_str = get_option_val(opt_grid, nullptr);
+ QString datum_str = get_option_val(opt_datum, nullptr);
+ QString grid_str = get_option_val(opt_grid, nullptr);
grid_index = grid_lat_lon_dmm;
- if (grid_str != nullptr) {
- int i;
+ if (!grid_str.isEmpty()) {
+ bool ok;
- if (sscanf(grid_str, "%d", &i)) {
+ if (int i = grid_str.toInt(&ok); ok) {
grid_index = (grid_type) i;
if ((grid_index < GRID_INDEX_MIN) || (grid_index > GRID_INDEX_MAX))
fatal(MYNAME ": Grid index out of range (%d..%d)!",
grid_str = grid_str.replace('*', u'°');
*fout << "Grid\t" << grid_str << "\r\n";
- datum_str = gt_get_mps_datum_name(datum_index);
- *fout << QString::asprintf("Datum\t%s\r\n\r\n", datum_str);
+ QString datum_str = gt_get_mps_datum_name(datum_index);
+ *fout << "Datum\t" << datum_str << "\r\n\r\n";
waypoints = 0;
gtxt_flags.enum_waypoints = 1; /* enum all waypoints */
return false;
}
- for (gt_display_modes_e i = GT_DISPLAY_MODE_MIN; i <= GT_DISPLAY_MODE_MAX; ++i) {
+ for (int i = 0; i < gt_display_mode_names.size(); ++i) {
if (case_ignore_strcmp(str, gt_display_mode_names[i]) == 0) {
*val = i;
return true;
fatal(MYNAME ": Missing grid headline!\n");
}
- const QByteArray ba = lineparts.at(0).toUtf8();
- const char* str = ba.constData();
- if (strstr(str, "dd.ddddd") != nullptr) {
+ const QString str = lineparts.at(0);
+ if (str.contains("dd.ddddd")) {
grid_index = grid_lat_lon_ddd;
- } else if (strstr(str, "mm.mmm") != nullptr) {
+ } else if (str.contains("mm.mmm")) {
grid_index = grid_lat_lon_dmm;
- } else if (strstr(str, "mm'ss.s") != nullptr) {
+ } else if (str.contains("mm'ss.s")) {
grid_index = grid_lat_lon_dms;
} else {
grid_index = gt_lookup_grid_type(str, MYNAME);
}
const auto& str = lineparts.at(0);
- datum_index = gt_lookup_datum_index(CSTR(str), MYNAME);
+ datum_index = gt_lookup_datum_index(str, MYNAME);
}
void
}
break;
case 3:
- for (i = 0; i <= gt_waypt_class_map_line; i++) {
+ for (i = 0; i < gt_waypt_class_names.size(); i++) {
if (case_ignore_strcmp(str, gt_waypt_class_names[i]) == 0) {
garmin_fs_t::set_wpt_class(gmsd, i);
break;
int wpt_a_ct{};
grid_type grid_index{};
int datum_index{};
- const char* datum_str{};
int current_line{};
QString date_time_format;
int precision = 3;
if (ci > 0) {
writer->writeStartElement(QStringLiteral("extensions"));
writer->writeStartElement(QStringLiteral("gpxx:TrackExtension"));
- writer->writeTextElement(QStringLiteral("gpxx:DisplayColor"), QStringLiteral("%1")
- .arg(gt_color_name(ci)));
+ writer->writeTextElement(QStringLiteral("gpxx:DisplayColor"), gt_color_name(ci));
writer->writeEndElement(); // Close gpxx:TrackExtension tag
writer->writeEndElement(); // Close extensions tag
}
writer->writeStartElement(QStringLiteral("gpxx:RouteExtension"));
// FIXME: the value to use for IsAutoNamed is questionable.
writer->writeTextElement(QStringLiteral("gpxx:IsAutoNamed"), rte->rte_name.isEmpty()? QStringLiteral("true") : QStringLiteral("false")); // Required element
- writer->writeTextElement(QStringLiteral("gpxx:DisplayColor"), QStringLiteral("%1")
- .arg(gt_color_name(ci)));
+ writer->writeTextElement(QStringLiteral("gpxx:DisplayColor"), gt_color_name(ci));
writer->writeEndElement(); // Close gpxx:RouteExtension tag
writer->writeEndElement(); // Close extensions tag
}
#include <algorithm> // for sort
#include <cstdio> // for printf
-#include <cstring> // for strcmp
+#include <QString> // for QString, operator<
#include <QVector> // for QVector<>::iterator, QVector
-#include "garmin_icon_tables.h" // for garmin_icon_table, garmin_smart_icon_table
-#include "garmin_tables.h" // for icon_mapping_t
+#include "garmin_icon_tables.h" // for icon_mapping_t, garmin_icon_table, garmin_smart_icon_table
int main()
{
QVector<icon_mapping_t> table;
- for (const icon_mapping_t* entry = garmin_icon_table; entry->icon; entry++) {
- table.append(*entry);
- }
- for (const icon_mapping_t* entry = garmin_smart_icon_table; entry->icon; entry++) {
- table.append(*entry);
- }
+ table.append(garmin_icon_table);
+ table.append(garmin_smart_icon_table);
auto sort_lambda = [](const icon_mapping_t& a, const icon_mapping_t& b)->bool {
- return strcmp(a.icon, b.icon) < 0;
+ return a.icon < b.icon;
};
std::sort(table.begin(), table.end(), sort_lambda);
for (const auto& entry : table) {
- printf(" <member>%s</member>\n",entry.icon);
+ printf(" <member>%s</member>\n", qPrintable(entry.icon));
}
return 0;
unicsv_detect = (!(global_opts.masked_objective & (WPTDATAMASK | TRKDATAMASK | RTEDATAMASK | POSNDATAMASK)));
unicsv_track = unicsv_route = nullptr;
- unicsv_datum_idx = gt_lookup_datum_index(opt_datum, MYNAME);
+ unicsv_datum_idx = gt_lookup_datum_index(opt_datum.get(), MYNAME);
fin = new gpsbabel::TextStream;
fin->open(fname, QIODevice::ReadOnly, MYNAME, opt_codec);
fatal(MYNAME ": %s (%s) is outside of convertible area of grid \"%s\"!\n",
wpt->shortname.isEmpty() ? "Waypoint" : qPrintable(wpt->shortname),
qPrintable(pretty_deg_format(wpt->latitude, wpt->longitude, 'd', nullptr, false)),
- gt_get_mps_grid_longname(unicsv_grid_idx, MYNAME));
+ qPrintable(gt_get_mps_grid_longname(unicsv_grid_idx, MYNAME)));
}
void
fatal(MYNAME ": Grid index out of range (%d..%d)!\n",
(int)GRID_INDEX_MIN, (int)GRID_INDEX_MAX);
} else {
- unicsv_grid_idx = gt_lookup_grid_type(opt_grid, MYNAME);
+ unicsv_grid_idx = gt_lookup_grid_type(opt_grid.get(), MYNAME);
}
}
{
unicsv_datum_idx = kDatumWGS84; /* internal, becomes CH1903 */
} else {
- unicsv_datum_idx = gt_lookup_datum_index(opt_datum, MYNAME);
+ unicsv_datum_idx = gt_lookup_datum_index(opt_datum.get(), MYNAME);
}
llprec = xstrtoi(opt_prec, nullptr, 10);
projects / gpsbabel.git / commitdiff